{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 量子费舍信息\n",
    "\n",
    "<em> Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. </em>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 概览\n",
    "\n",
    "本教程简要介绍经典费舍信息（classical Fisher information, CFI）和量子费舍信息（quantum Fisher information, QFI）的概念及其在量子机器学习中的应用，并展示如何调用量桨来计算它们。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 背景\n",
    "\n",
    "量子费舍信息这一概念源自量子传感领域，现已逐渐成为研究参数化量子系统的通用工具 [[1]](https://arxiv.org/abs/2103.15191)，例如描述过参数化现象 [[2]](https://arxiv.org/abs/2102.01659)，量子自然梯度下降 [[3]](https://arxiv.org/abs/1909.02108) 等。量子费舍信息是经典费舍信息在量子系统中的自然类比。经典费舍信息刻画了一个参数化的『概率分布』对其参数变化的灵敏度，而量子费舍信息刻画了一个参数化的『量子态』对其参数变化的灵敏度。\n",
    "\n",
    "按照传统的介绍方式，经典费舍信息会作为数理统计中参数估计的一部分内容出现，但对于初学者来说可能是复杂且不直观的。本教程将从几何的角度出发来介绍经典费舍信息，这不仅有助于直观理解，且更容易由此看出其与量子费舍信息之间的联系。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 经典费舍信息\n",
    "\n",
    "首先介绍经典费舍信息。对于一个参数化的概率分布 $p(\\boldsymbol{x};\\boldsymbol{\\theta})$，考虑如下问题\n",
    "\n",
    "- 一个轻微的参数改变会在多大程度上造成概率分布的改变？\n",
    "\n",
    "这是个关于微扰的问题，所以自然地想到做类似泰勒展开的操作。但在此之前，我们需要知道展开哪个函数，即我们需要量化『概率分布的改变』。更正式的说法是，我们需要定义任意两个概率分布之间的『距离』，记为 $d(p(\\boldsymbol{x};\\boldsymbol{\\theta}),p(\\boldsymbol{x};\\boldsymbol{\\theta}'))$，或简记为 $d(\\boldsymbol{\\theta},\\boldsymbol{\\theta}')$。\n",
    "\n",
    "一般地，一个合法的距离定义应该是非负的，当且仅当两点重合时为零，即\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "&d(\\boldsymbol{\\theta},\\boldsymbol{\\theta}')\\geq 0,\\\\\n",
    "&d(\\boldsymbol{\\theta},\\boldsymbol{\\theta}')=0~\\Leftrightarrow~\\boldsymbol{\\theta}=\\boldsymbol{\\theta}'.\n",
    "\\end{aligned}\n",
    "\\tag{1}\n",
    "$$\n",
    "\n",
    "考虑一个很短的距离函数的展开 $d(\\boldsymbol{\\theta},\\boldsymbol{\\theta}+\\boldsymbol{\\delta})$，以上条件会导致\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "&d(\\boldsymbol{\\theta},\\boldsymbol{\\theta})=0~\\Rightarrow~\\text{零阶项}=0,\\\\\n",
    "&d(\\boldsymbol{\\theta},\\boldsymbol{\\theta}+\\boldsymbol{\\delta})\\geq 0~\\Rightarrow~\\boldsymbol{\\delta}=0~\\text{取极小值}\n",
    "~\\Rightarrow~\\text{一阶项}=0.\n",
    "\\end{aligned}\n",
    "\\tag{2}\n",
    "$$\n",
    "\n",
    "因此，在这个展开中最低阶的非零贡献来自二阶。因此它可被写为\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "d(\\boldsymbol{\\theta},\\boldsymbol{\\theta}+\\boldsymbol{\\delta})\n",
    "=\\frac{1}{2}\\sum_{ij}\\delta_iM_{ij}\\delta_j+O(\\|\\boldsymbol{\\delta}\\|^3) \n",
    "=\\frac{1}{2} \\boldsymbol{\\delta}^T M \\boldsymbol{\\delta} + O(\\|\\boldsymbol{\\delta}\\|^3),\n",
    "\\end{aligned}\n",
    "\\tag{3}\n",
    "$$\n",
    "\n",
    "此处\n",
    "\n",
    "$$\n",
    "M_{ij}(\\boldsymbol{\\theta})=\\left.\\frac{\\partial^2}{\\partial\\delta_i\\partial\\delta_j}d(\\boldsymbol{\\theta},\\boldsymbol{\\theta}+\\boldsymbol{\\delta})\\right|_{\\boldsymbol{\\delta}=0},\n",
    "\\tag{4}\n",
    "$$\n",
    "\n",
    "正是这个距离函数展开的海森矩阵。在微分几何的框架下，这称作流形的[度规](http://en.wikipedia.org/wiki/Metric_tensor)。以上简单的推导说明，我们总是可以用参数的一个二次型来近似表示一小段距离（如图1）。而二次型的系数矩阵，除了有一个 $1/2$ 因子的差别外，正是距离函数展开的海森矩阵。\n",
    "\n",
    "![feature map](./figures/FIM-fig-Sphere-metric.png \"Figure 1. Approximate a small distance on the 2-sphere as a quadratic form\")\n",
    "<div style=\"text-align:center\">图 1. 将一小段距离近似为二次型，此处以二维球面为例绘制 </div>\n",
    "\n",
    "如果我们定义概率分布之间的距离为相对熵或称 KL 散度\n",
    "\n",
    "$$\n",
    "d_{\\mathrm{KL}}(\\boldsymbol{\\theta}, \\boldsymbol{\\theta}^{\\prime})=\\sum_{\\boldsymbol{x}} p(\\boldsymbol{x};\\boldsymbol{\\theta}) \\log \\frac{p(\\boldsymbol{x};\\boldsymbol{\\theta})}{p(\\boldsymbol{x};\\boldsymbol{\\theta}^{\\prime})}.\n",
    "\\tag{5}\n",
    "$$\n",
    "\n",
    "对应的海森矩阵为\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\mathcal{I}_{ij}(\\boldsymbol{\\theta})&= \\left.\\frac{\\partial^2}{\\partial\\delta_i\\partial\\delta_j}d_{\\mathrm{KL}}(\\boldsymbol{\\theta},\\boldsymbol{\\theta}+\\boldsymbol{\\delta})\\right|_{\\boldsymbol{\\delta}=0}\\\\\n",
    "&=-\\sum_{\\boldsymbol{x}} p(\\boldsymbol{x};\\boldsymbol{\\theta}) \\partial_{i} \\partial_{j} \\log p(\\boldsymbol{x};\\boldsymbol{\\theta})\n",
    "=\\mathbb{E}_{\\boldsymbol{x}}[-\\partial_{i} \\partial_{j} \\log p(\\boldsymbol{x};\\boldsymbol{\\theta})] \\\\\n",
    "&=\\sum_{\\boldsymbol{x}}  \\frac{1}{p(\\boldsymbol{x};\\boldsymbol{\\theta})} \\partial_i p(\\boldsymbol{x};\\boldsymbol{\\theta}) \\cdot \\partial_j p(\\boldsymbol{x};\\boldsymbol{\\theta})\n",
    "=\\mathbb{E}_{\\boldsymbol{x}}[\\partial_i\\log p(\\boldsymbol{x};\\boldsymbol{\\theta})\\cdot \\partial_j \\log p(\\boldsymbol{x};\\boldsymbol{\\theta})].\n",
    "\\end{aligned}\n",
    "\\tag{6}\n",
    "$$\n",
    "\n",
    "这就是所谓的经典费舍信息矩阵（classical Fisher information matrix, CFIM），矩阵元越大说明概率分布对相应的参数变化越灵敏。上式中我们使用了偏导数符号的简记 $\\partial_i=\\partial/\\partial \\theta_i$。\n",
    "\n",
    "为什么 $\\mathcal{I}(\\boldsymbol{\\theta})$ 称为『信息』？这是因为，CFIM 刻画了概率分布在对应参数一个领域内的灵敏度，或称锐度。对参数变化越灵敏，说明我们越容易将其同其它概率分布区分开来，进一步地，说明我们需要越少的样本就可以完成这种区分，那么每个样本中平均所含的信息量就越多。\n",
    "\n",
    "参数化量子电路（parameterized quantum circuit, PQC）的测量结果会形成一个概率分布，因此可以对不同的测量基定义不同的 CFIM。目前在 NISQ 设备上计算 CFIM 的主要挑战是，可能出现的测量结果的数量会随着量子比特数的增加而指数地增加，这意味着可能有很多小概率的测量结果从未出现过，导致 CFIM 的计算出现发散。一些可能的解决方案包括直接忽略小的概率事件，以及贝叶斯更新等 [[1]](https://arxiv.org/abs/2103.15191)。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 量子费舍信息\n",
    "\n",
    "量子费舍信息是经典费舍信息的自然类比，只是距离函数不再定义在两个概率分布之间，而是定义在两个量子态之间。我们通常选用保真度距离\n",
    "\n",
    "$$\n",
    "d_f(\\boldsymbol{\\theta},\\boldsymbol{\\theta}')=2-2|\\langle\\psi(\\boldsymbol{\\theta})|\\psi(\\boldsymbol{\\theta}')\\rangle|^2.\n",
    "\\tag{7}\n",
    "$$\n",
    "\n",
    "此处因子 $2$ 是人为乘上去的，为的是让后续的结果与 CFIM 对应上。一个参数化量子纯态 $|\\psi(\\boldsymbol{\\theta})\\rangle, \\boldsymbol{\\theta}\\in\\mathbb{R}^m$ 的量子费舍信息矩阵（quantum Fisher information matrix, QFIM）就是保真度距离展开的海森矩阵，即\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\mathcal{F}_{ij}(\\boldsymbol{\\theta})\n",
    "&= \\left.\\frac{\\partial^2}{\\partial\\delta_i\\partial\\delta_j}d_{f}(\\boldsymbol{\\theta},\\boldsymbol{\\theta}+\\boldsymbol{\\delta})\\right|_{\\boldsymbol{\\delta}=0} \\\\\n",
    "&=4 \\operatorname{Re}\\left[\\left\\langle\\partial_{i} \\psi \\mid \\partial_{j} \\psi\\right\\rangle - \\left\\langle\\partial_{i} \\psi \\mid \\psi\\right\\rangle\\left\\langle\\psi \\mid \\partial_{j} \\psi\\right\\rangle\\right],\n",
    "\\end{aligned}\n",
    "\\tag{8}\n",
    "$$\n",
    "\n",
    "上式中简洁起见我们略写了自变量 $\\boldsymbol{\\theta}$。与 CFIM 类似，QFIM 刻画了参数化量子态对参数微小变化的灵敏度。此外值得一提的是，QFIM 可以被视为另一个被称作量子几何张量的复数矩阵的实部，或称为 Fubini-Study 度规 [[1]](https://arxiv.org/abs/2103.15191)。\n",
    "\n",
    "目前，人们已经提出了一些在 NISQ 设备上计算纯态 QFIM 的方法，其中最直接的两个方法是\n",
    "\n",
    "- 利用二阶参数平移规则计算每个矩阵元 [[4]](https://arxiv.org/abs/2008.06517)\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\mathcal{F}_{i j}=-\\frac{1}{2} \\Big(&|\\langle\\psi(\\boldsymbol{\\theta}) \\mid \\psi(\\boldsymbol{\\theta}+(\\boldsymbol{e}_{i}+\\boldsymbol{e}_{j}) \\frac{\\pi}{2})\\rangle|^{2}\n",
    "-|\\langle\\psi(\\boldsymbol{\\theta}) \\mid \\psi(\\boldsymbol{\\theta}+(\\boldsymbol{e}_{i}-\\boldsymbol{e}_{j}) \\frac{\\pi}{2})\\rangle|^{2}\\\\\n",
    "-&|\\langle\\psi(\\boldsymbol{\\theta}) \\mid \\psi(\\boldsymbol{\\theta}-(\\boldsymbol{e}_{i}-\\boldsymbol{e}_{j}) \\frac{\\pi}{2})\\rangle|^{2}\n",
    "+|\\langle\\psi(\\boldsymbol{\\theta}) \\mid \\psi(\\boldsymbol{\\theta}-(\\boldsymbol{e}_{i}+\\boldsymbol{e}_{j}) \\frac{\\pi}{2})\\rangle|^{2}\\Big),\n",
    "\\end{aligned}\n",
    "\\tag{9}\n",
    "$$\n",
    "其中 $\\boldsymbol{e}_{i}$ 是 $\\theta_i$ 对应方向的单位向量。值得注意的是，参数平移规则不能直接适用于单比特旋转门的参数间有依赖关系的情况，例如受控旋转门等。\n",
    "\n",
    "- 利用有限差分计算 QFIM 沿一个确定方向的投影 [[1]](https://arxiv.org/abs/2103.15191)\n",
    "$$\n",
    "\\boldsymbol{v}^{T} \\mathcal{F} \\boldsymbol{v} \\approx \\frac{4 d_{f}(\\boldsymbol{\\theta}, \\boldsymbol{\\theta}+\\epsilon \\boldsymbol{v})}{\\epsilon^{2}}.\n",
    "\\tag{10}\n",
    "$$\n",
    "这个量可以被视为著名的 Fisher-Rao 模在量子态空间的类比。\n",
    "\n",
    "对于混态，QFIM 可以类似地通过 Bures 保真度距离的展开来定义\n",
    "\n",
    "$$\n",
    "d_B(\\boldsymbol{\\theta},\\boldsymbol{\\theta}')\\equiv \n",
    "2-2\\left[\\text{Tr}\\left([\\sqrt{\\rho(\\boldsymbol{\\theta})} \\rho(\\boldsymbol{\\theta}')\\sqrt{\\rho(\\boldsymbol{\\theta})}]^{1/2}\\right)\\right]^2,\n",
    "\\tag{11}\n",
    "$$\n",
    "\n",
    "或者等价地（$\\log x\\sim x-1$），通过如下形式的 $\\alpha=1/2$ 的 Rényi 相对熵的展开来定义 [[5]](https://arxiv.org/abs/1308.5961)\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "d_R(\\boldsymbol{\\theta},\\boldsymbol{\\theta}') &\\equiv 2\\widetilde{D}_{\\alpha=1/2}(\\rho(\\boldsymbol{\\theta'}) \\| \\rho(\\boldsymbol{\\theta})), \\\\\n",
    "\\widetilde{D}_{\\alpha}(\\rho \\| \\sigma) \n",
    "&\\equiv \n",
    "\\frac{1}{\\alpha-1} \\log \\operatorname{Tr}\\left[\\left(\\sigma^{\\frac{1-\\alpha}{2 \\alpha}} \\rho \\sigma^{\\frac{1-\\alpha}{2 \\alpha}}\\right)^{\\alpha}\\right].\\\\\n",
    "\\end{aligned}\n",
    "\\tag{12}\n",
    "$$\n",
    "\n",
    "更多细节请参考这篇综述 [[1]](https://arxiv.org/abs/2103.15191) 。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 经典与量子费舍信息的关系\n",
    "\n",
    "根据定义，对于一个参数化的量子电路，CFIM 依赖于测量基，而 QFIM 不依赖。事实上可以证明，一个量子态 $\\rho(\\boldsymbol{\\theta})$ 的 QFIM 是其在任意测量基下对应 CFIM 的一个上限，即\n",
    "\n",
    "$$\n",
    "\\mathcal{I}[\\mathcal{E}[\\rho(\\boldsymbol{\\theta})]]\\leq \\mathcal{F}[\\rho(\\boldsymbol{\\theta})],~\\forall\\mathcal{E},\n",
    "\\tag{13}\n",
    "$$\n",
    "\n",
    "此处 $\\mathcal{E}$ 表示测量对应的量子操作。正定矩阵间不等式的含义是，大的减去小的结果仍然是一个正定矩阵。由于对量子态的测量永远无法提取出比量子态本身更多的信息，因此上式的成立是很自然的。数学上这根源于保真度距离对于保迹量子操作的单调性 [[1]](https://arxiv.org/abs/2103.15191)。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 应用：有效维数\n",
    "\n",
    "经典/量子费舍信息矩阵的秩在参数空间的最大值可以用来衡量神经网络表达能力，称为经典/量子有效维数\n",
    "\n",
    "$$\n",
    "d_{\\text{eff}}=\\underset{\\boldsymbol{\\theta}\\in\\Theta} {\\max}\n",
    "\\operatorname{rank}{\\mathcal{F}}(\\boldsymbol{\\theta}).\n",
    "\\tag{14}\n",
    "$$\n",
    "\n",
    "秩的大小刻画了参数变化会造成概率分布/量子态变化的方向的数量。非满秩意味着有一些特定方向的参数变化不能实际地导致概率分布/量子态发生变化，或者说有一些参数自由度是冗余的，可以把它们从模型中投影掉，因此这种现象被称作过参数化。另一方面，有效维数越大，对应着更多可以延伸的方向，这意味着模型对应的函数空间更大，即表达能力更强。\n",
    "\n",
    "在机器学习的语境下，『经验费舍信息矩阵』[[6]](https://arxiv.org/abs/2011.00027) 的使用更为广泛，它与 CFIM 的区别是用对样本的求和代替了求期望\n",
    "\n",
    "$$\n",
    "\\tilde{\\mathcal{I}}_{ij}(\\boldsymbol{\\theta})\n",
    "=\\frac{1}{n}\\sum_{k=1}^{n}\n",
    "\\partial_i\\log p(x_k,y_k;\\boldsymbol{\\theta})\n",
    "\\partial_j\\log p(x_k,y_k;\\boldsymbol{\\theta}),\n",
    "\\tag{15}\n",
    "$$\n",
    "\n",
    "此处 $(x_k,y_k)^{n}_{k=1}$ 是独立同分布的样本，分布为 $p(x,y;\\boldsymbol{\\theta})=p(y|x;\\boldsymbol{\\theta})p(x)$。显然，经验费舍信息矩阵在无限样本的极限下可以回到 CFIM，只要满足（1）模型被训练到全局最优；（2）模型拥有足够的表达能力来表达底层的数据分布。使用经验费舍信息矩阵的优势在于，它可以利用现成的样本直接计算，而不是为了计算公式中的积分而生成新的样本。\n",
    "\n",
    "利用经验费舍信息矩阵，我们可以定义有效维数的一个变体 \n",
    "\n",
    "$$\n",
    "d_{\\text{eff}}(\\gamma, n)=\n",
    "2 \\frac{\\log \\left(\\frac{1}{V_{\\Theta}} \\int_{\\Theta} \\sqrt{\\operatorname{det}\\left( 1 + \\frac{\\gamma n}{2 \\pi \\log n} \\hat{\\mathcal{I}}( \\boldsymbol{\\theta})\\right)} \\mathrm{d}  \\boldsymbol{\\theta} \\right)}\n",
    "{\\log \\left(\\frac{\\gamma n}{2 \\pi \\log n}\\right)},\n",
    "\\tag{16}\n",
    "$$\n",
    "\n",
    "其中 $V_{\\Theta}:=\\int_{\\Theta} \\mathrm{d} \\boldsymbol{\\theta} \\in \\mathbb{R}_{+}$ 是参数空间的体积。$\\gamma\\in(0,1]$ 是一个人为可调参数。$\\hat{\\mathcal{I}} (\\boldsymbol{\\theta}) \\in \\mathbb{R}^{d\\times d}$ 是归一化的经验费舍信息矩阵\n",
    "\n",
    "$$\n",
    "\\hat{\\mathcal{I}}_{i j}(\\boldsymbol{\\theta}):= \\frac{V_{\\Theta} d }{\\int_{\\Theta} \\operatorname{Tr}(F( \\boldsymbol{\\theta} ) \\mathrm{d} \\theta} \\tilde{\\mathcal{I}}_{i j}(\\boldsymbol{\\theta}).\n",
    "\\tag{17}\n",
    "$$\n",
    "\n",
    "这个定义乍看起来可能很迷惑，因为它比上文通过秩来定义要复杂得多。然而，它实际上可以在无限样本的极限下 $n\\rightarrow \\infty$  回到 CFIM 最大秩的定义 [[6]](https://arxiv.org/abs/2011.00027)。若忽略定义中的一些系数和取对数的操作，此处定义的有效维数可以粗略地看作归一化 CFIM 加上一个单位矩阵的本征谱的几何平均。依据几何平均与算术平均间的不等式关系，可知本征谱分布越均匀，有效维数越大。这和我们的直觉是一致的。在这个意义上，它可以看作是一个软化版本的有效维数。\n",
    "\n",
    "另外，费舍信息不仅可以用来计算模型的表达能力，还可以用来表征模型的可训练性。如果费舍信息矩阵的矩阵元在参数空间的平均随体系规模的增大而指数地趋于零，即概率分布/量子态对参数变化的灵敏度指数地趋于零，那么我们将无法高效地区分它们，也就意味着贫瘠高原现象的存在 [[6]](https://arxiv.org/abs/2011.00027)。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 调用量桨计算费舍信息"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 计算量子费舍信息\n",
    "\n",
    "利用量桨工具，通过以下步骤我们就可以方便地算出 QFIM。\n",
    "\n",
    "1. 调用 `Circuit` 类定义一个量子电路。\n",
    "2. 调用 `QuantumFisher` 类定义一个 QFIM 计算器。\n",
    "3. 调用 `get_qfisher_matrix()` 方法计算 QFIM。\n",
    "\n",
    "其中计算器 `QuantumFisher` 会追踪量子电路 `Circuit` 的实时变化。\n",
    "\n",
    "现在来着手写代码。首先导入一些必要的包。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import paddle\n",
    "from paddle_quantum.ansatz import Circuit\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from paddle_quantum.fisher import QuantumFisher, ClassicalFisher\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "然后定义量子电路。作为一个简单的例子，我们采用布洛赫角表示的单个量子比特\n",
    "\n",
    "$$\n",
    "|\\psi(\\theta,\\phi)\\rangle=R_z(\\phi)R_y(\\theta)|0\\rangle=e^{-i\\phi/2}\\cos\\frac{\\theta}{2}|0\\rangle+e^{i\\phi/2}\\sin\\frac{\\theta}{2}|1\\rangle.\n",
    "\\tag{18}\n",
    "$$\n",
    "\n",
    "利用 (8) 式可以计算出对应 QFIM 的解析表达式为\n",
    "\n",
    "$$\n",
    "\\mathcal{F}(\\theta,\\phi)=\\left(\\begin{matrix}\n",
    "1&0\\\\\n",
    "0&\\sin^2\\theta\n",
    "\\end{matrix}\\right).\n",
    "\\tag{19}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def circuit_bloch():\n",
    "    cir = Circuit(1)\n",
    "    cir.ry()\n",
    "    cir.rz()\n",
    "    return cir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Ry(0.826)----Rz(4.587)--\n",
      "                          \n"
     ]
    }
   ],
   "source": [
    "cir = circuit_bloch()\n",
    "print(cir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义 QFIM 计算器然后计算不同 $\\theta$ 对应的 QFIM 矩阵元 $\\mathcal{F}_{\\phi\\phi}$ 。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The QFIM at [0.         4.58719969] is \n",
      " [[1. 0.]\n",
      " [0. 0.]].\n",
      "The QFIM at [0.15707963 4.58719969] is \n",
      " [[1.         0.        ]\n",
      " [0.         0.02447182]].\n",
      "The QFIM at [0.31415927 4.58719969] is \n",
      " [[1.         0.        ]\n",
      " [0.         0.09549146]].\n",
      "The QFIM at [0.4712389  4.58719969] is \n",
      " [[1.         0.        ]\n",
      " [0.         0.20610736]].\n",
      "The QFIM at [0.62831853 4.58719969] is \n",
      " [[ 1.0000000e+00 -8.1719260e-08]\n",
      " [-8.1719260e-08  3.4549149e-01]].\n",
      "The QFIM at [0.78539816 4.58719969] is \n",
      " [[ 1.00000000e+00 -1.49011600e-08]\n",
      " [-1.49011600e-08  5.00000017e-01]].\n",
      "The QFIM at [0.9424778  4.58719969] is \n",
      " [[ 1.00000000e+00 -3.05229200e-08]\n",
      " [-3.05229200e-08  6.54508507e-01]].\n",
      "The QFIM at [1.09955743 4.58719969] is \n",
      " [[1.         0.        ]\n",
      " [0.         0.79389268]].\n",
      "The QFIM at [1.25663706 4.58719969] is \n",
      " [[ 9.99999881e-01 -1.25257100e-08]\n",
      " [-1.25257100e-08  9.04508410e-01]].\n",
      "The QFIM at [1.41371669 4.58719969] is \n",
      " [[1.         0.        ]\n",
      " [0.         0.97552822]].\n",
      "The QFIM at [1.57079633 4.58719969] is \n",
      " [[0.99999988 0.        ]\n",
      " [0.         0.99999988]].\n",
      "The QFIM at [1.72787596 4.58719969] is \n",
      " [[9.99999881e-01 5.18176500e-08]\n",
      " [5.18176500e-08 9.75528170e-01]].\n",
      "The QFIM at [1.88495559 4.58719969] is \n",
      " [[1.00000024e+00 4.79417900e-08]\n",
      " [4.79417900e-08 9.04508749e-01]].\n",
      "The QFIM at [2.04203522 4.58719969] is \n",
      " [[1.00000000e+00 6.73742000e-08]\n",
      " [6.73742000e-08 7.93892595e-01]].\n",
      "The QFIM at [2.19911486 4.58719969] is \n",
      " [[1.00000000e+00 8.17192500e-08]\n",
      " [8.17192500e-08 6.54508507e-01]].\n",
      "The QFIM at [2.35619449 4.58719969] is \n",
      " [[0.99999976 0.        ]\n",
      " [0.         0.49999986]].\n",
      "The QFIM at [2.51327412 4.58719969] is \n",
      " [[1.0000000e+00 8.1719250e-08]\n",
      " [8.1719250e-08 3.4549149e-01]].\n",
      "The QFIM at [2.67035376 4.58719969] is \n",
      " [[0.99999988 0.        ]\n",
      " [0.         0.20610746]].\n",
      "The QFIM at [2.82743339 4.58719969] is \n",
      " [[ 1.00000000e+00 -3.54160700e-08]\n",
      " [-3.54160700e-08  9.54916844e-02]].\n",
      "The QFIM at [2.98451302 4.58719969] is \n",
      " [[0.99999976 0.        ]\n",
      " [0.         0.02447181]].\n",
      "The QFIM at [3.14159265 4.58719969] is \n",
      " [[ 1.0000000e+00 -1.2644054e-07]\n",
      " [-1.2644054e-07  0.0000000e+00]].\n"
     ]
    }
   ],
   "source": [
    "qf = QuantumFisher(cir)\n",
    "# 记录 QFIM 的矩阵元 F_{phi,phi}\n",
    "list_qfisher_elements = []\n",
    "num_thetas = 21\n",
    "thetas = np.linspace(0, np.pi, num_thetas)\n",
    "for theta in thetas:\n",
    "    list_param = cir.param.tolist()\n",
    "    list_param[0] = theta\n",
    "    cir.update_param(list_param)\n",
    "    # 计算 QFIM\n",
    "    qfim = qf.get_qfisher_matrix()\n",
    "    print(f'The QFIM at {np.array(list_param)} is \\n {qfim.round(14)}.')\n",
    "    list_qfisher_elements.append(qfim[1][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "画出 $\\mathcal{F}_{\\phi\\phi}$ 随 $\\theta$ 变化的图像。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 648x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 创建图像\n",
    "fig = plt.figure(figsize=(9, 6))\n",
    "ax = fig.add_subplot(111)\n",
    "# 绘制 QFIM\n",
    "ax.plot(thetas, list_qfisher_elements, 's', markersize=11, markerfacecolor='none')\n",
    "# 绘制 sin^2 theta\n",
    "ax.plot(thetas, np.sin(thetas) ** 2, linestyle=(0, (5, 3)))\n",
    "# 设置图例，标签，刻度\n",
    "label_font_size = 18\n",
    "ax.legend(['get_qfisher_matrix()[1][1]', '$\\\\sin^2\\\\theta$'], \n",
    "          prop= {'size': label_font_size}, frameon=False) \n",
    "ax.set_xlabel('$\\\\theta$', fontsize=label_font_size)\n",
    "ax.set_ylabel('QFIM element $\\\\mathcal{F}_{\\\\phi\\\\phi}$', fontsize=label_font_size)\n",
    "ax.tick_params(labelsize=label_font_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到程序输出和解析结果是一致的。\n",
    "\n",
    "此外，我们还可以调用 `get_qfisher_norm()` 方法来计算式 (10) 中的量子费舍信息矩阵在某个方向的投影。\n",
    "\n",
    "举一个和上面不同的例子，两个量子比特上的一个典型的 hardware-efficient 拟设\n",
    "\n",
    "$$\n",
    "|\\psi(\\boldsymbol{\\theta})\\rangle=\\left[R_{y}\\left( \\theta_{3}\\right) \\otimes R_{y}\\left( \\theta_{4}\\right)\\right] \\text{CNOT}_{0,1}\\left[ R_{y}\\left( \\theta_{1}\\right) \\otimes R_{y}\\left( \\theta_{2}\\right)\\right]|00\\rangle.\n",
    "\\tag{20}\n",
    "$$\n",
    "\n",
    "对应的 QFIM 为\n",
    "\n",
    "$$\n",
    "\\mathcal{F}(\\theta_1,\\theta_2,\\theta_3,\\theta_4)=\\left(\\begin{array}{cc|cc}\n",
    "1 & 0 & \\sin  \\theta_{2} & 0 \\\\\n",
    "0 & 1 & 0 & \\cos  \\theta_{1} \\\\\n",
    "\\hline \n",
    "\\sin \\theta_{2} & 0 & 1 & -\\sin\\theta_1\\cos\\theta_2 \\\\\n",
    "0 & \\cos \\theta_{1} & -\\sin\\theta_1\\cos\\theta_2 & 1\n",
    "\\end{array}\\right).\n",
    "\\tag{21}\n",
    "$$\n",
    "\n",
    "定义相应的量子电路。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def circuit_hardeff_2qubit():\n",
    "    cir = Circuit(2)\n",
    "    cir.ry()\n",
    "    cir.cnot([0, 1])\n",
    "    cir.ry()\n",
    "\n",
    "    return cir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Ry(3.322)----*----Ry(1.502)--\n",
      "               |               \n",
      "--Ry(2.820)----x----Ry(6.056)--\n",
      "                               \n"
     ]
    }
   ],
   "source": [
    "cir = circuit_hardeff_2qubit()\n",
    "print(cir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义 QFIM 计算器并计算不同 $\\theta$ 对应的 QFIM 在 $\\boldsymbol{v}=(1,1,1,1)$ 方向上的投影 $\\boldsymbol{v}^T\\mathcal{F}\\boldsymbol{v}$ （固定 $\\theta_1=\\theta_2=\\theta$）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The QFI norm along [1, 1, 1, 1] at [0.         0.         1.50244081 6.05584192] is 6.00315457.\n",
      "The QFI norm along [1, 1, 1, 1] at [0.31415927 0.31415927 1.50244081 6.05584192] is 5.91733027.\n",
      "The QFI norm along [1, 1, 1, 1] at [0.62831853 0.62831853 1.50244081 6.05584192] is 5.83627391.\n",
      "The QFI norm along [1, 1, 1, 1] at [0.9424778  0.9424778  1.50244081 6.05584192] is 5.83150589.\n",
      "The QFI norm along [1, 1, 1, 1] at [1.25663706 1.25663706 1.50244081 6.05584192] is 5.92686631.\n",
      "The QFI norm along [1, 1, 1, 1] at [1.57079633 1.57079633 1.50244081 6.05584192] is 6.00792258.\n",
      "The QFI norm along [1, 1, 1, 1] at [1.88495559 1.88495559 1.50244081 6.05584192] is 5.85534601.\n",
      "The QFI norm along [1, 1, 1, 1] at [2.19911486 2.19911486 1.50244081 6.05584192] is 5.38331038.\n",
      "The QFI norm along [1, 1, 1, 1] at [2.51327412 2.51327412 1.50244081 6.05584192] is 4.49167993.\n",
      "The QFI norm along [1, 1, 1, 1] at [2.82743339 2.82743339 1.50244081 6.05584192] is 3.27580421.\n",
      "The QFI norm along [1, 1, 1, 1] at [3.14159265 3.14159265 1.50244081 6.05584192] is 1.98361799.\n",
      "The QFI norm along [1, 1, 1, 1] at [3.45575192 3.45575192 1.50244081 6.05584192] is 0.86783892.\n",
      "The QFI norm along [1, 1, 1, 1] at [3.76991118 3.76991118 1.50244081 6.05584192] is 0.24795494.\n",
      "The QFI norm along [1, 1, 1, 1] at [4.08407045 4.08407045 1.50244081 6.05584192] is 0.26226001.\n",
      "The QFI norm along [1, 1, 1, 1] at [4.39822972 4.39822972 1.50244081 6.05584192] is 0.90598547.\n",
      "The QFI norm along [1, 1, 1, 1] at [4.71238898 4.71238898 1.50244081 6.05584192] is 2.02176400.\n",
      "The QFI norm along [1, 1, 1, 1] at [5.02654825 5.02654825 1.50244081 6.05584192] is 3.31871778.\n",
      "The QFI norm along [1, 1, 1, 1] at [5.34070751 5.34070751 1.50244081 6.05584192] is 4.53936095.\n",
      "The QFI norm along [1, 1, 1, 1] at [5.65486678 5.65486678 1.50244081 6.05584192] is 5.40715063.\n",
      "The QFI norm along [1, 1, 1, 1] at [5.96902604 5.96902604 1.50244081 6.05584192] is 5.87441809.\n",
      "The QFI norm along [1, 1, 1, 1] at [6.28318531 6.28318531 1.50244081 6.05584192] is 6.00315457.\n",
      "The QFI norm along [1, 1, 1, 1] at [6.59734457 6.59734457 1.50244081 6.05584192] is 5.92209829.\n",
      "The QFI norm along [1, 1, 1, 1] at [6.91150384 6.91150384 1.50244081 6.05584192] is 5.83627391.\n",
      "The QFI norm along [1, 1, 1, 1] at [7.2256631  7.2256631  1.50244081 6.05584192] is 5.83150589.\n",
      "The QFI norm along [1, 1, 1, 1] at [7.53982237 7.53982237 1.50244081 6.05584192] is 5.92686631.\n",
      "The QFI norm along [1, 1, 1, 1] at [7.85398163 7.85398163 1.50244081 6.05584192] is 6.00792258.\n",
      "The QFI norm along [1, 1, 1, 1] at [8.1681409  8.1681409  1.50244081 6.05584192] is 5.87441809.\n",
      "The QFI norm along [1, 1, 1, 1] at [8.48230016 8.48230016 1.50244081 6.05584192] is 5.38331038.\n",
      "The QFI norm along [1, 1, 1, 1] at [8.79645943 8.79645943 1.50244081 6.05584192] is 4.48691182.\n",
      "The QFI norm along [1, 1, 1, 1] at [9.1106187  9.1106187  1.50244081 6.05584192] is 3.28534056.\n",
      "The QFI norm along [1, 1, 1, 1] at [9.42477796 9.42477796 1.50244081 6.05584192] is 1.97884973.\n",
      "The QFI norm along [1, 1, 1, 1] at [9.73893723 9.73893723 1.50244081 6.05584192] is 0.87737556.\n",
      "The QFI norm along [1, 1, 1, 1] at [10.05309649 10.05309649  1.50244081  6.05584192] is 0.24318658.\n",
      "The QFI norm along [1, 1, 1, 1] at [10.36725576 10.36725576  1.50244081  6.05584192] is 0.26702836.\n",
      "The QFI norm along [1, 1, 1, 1] at [10.68141502 10.68141502  1.50244081  6.05584192] is 0.90598547.\n",
      "The QFI norm along [1, 1, 1, 1] at [10.99557429 10.99557429  1.50244081  6.05584192] is 2.01222750.\n",
      "The QFI norm along [1, 1, 1, 1] at [11.30973355 11.30973355  1.50244081  6.05584192] is 3.32348596.\n",
      "The QFI norm along [1, 1, 1, 1] at [11.62389282 11.62389282  1.50244081  6.05584192] is 4.52028855.\n",
      "The QFI norm along [1, 1, 1, 1] at [11.93805208 11.93805208  1.50244081  6.05584192] is 5.39761453.\n",
      "The QFI norm along [1, 1, 1, 1] at [12.25221135 12.25221135  1.50244081  6.05584192] is 5.86965007.\n",
      "The QFI norm along [1, 1, 1, 1] at [12.56637061 12.56637061  1.50244081  6.05584192] is 5.99838655.\n"
     ]
    }
   ],
   "source": [
    "qf = QuantumFisher(cir)\n",
    "v = [1, 1, 1, 1]\n",
    "# 记录 QFIM 投影\n",
    "list_qfisher_norm = []\n",
    "num_thetas = 41\n",
    "thetas = np.linspace(0, np.pi * 4, num_thetas)\n",
    "for theta in thetas:\n",
    "    list_param = cir.param.tolist()\n",
    "    list_param[0] = theta\n",
    "    list_param[1] = theta\n",
    "    cir.update_param(list_param)\n",
    "    # 计算 QFIM 投影\n",
    "    qfisher_norm = qf.get_qfisher_norm(v)\n",
    "    print(\n",
    "        f'The QFI norm along {v} at {np.array(list_param)} is {qfisher_norm:.8f}.'\n",
    "    )\n",
    "    list_qfisher_norm.append(qfisher_norm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 648x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 创建图像\n",
    "fig = plt.figure(figsize=(9, 6))\n",
    "ax = fig.add_subplot(111)\n",
    "# 绘制 QFIM 投影\n",
    "ax.plot(thetas, list_qfisher_norm, 's', markersize=11, markerfacecolor='none')\n",
    "analytical_qfi_norm = 4 + 2 * np.sin(thetas) + 2 * np.cos(thetas) - 2 * np.cos(thetas) * np.sin(thetas)\n",
    "ax.plot(thetas, analytical_qfi_norm, linestyle=(0, (5, 3)))\n",
    "# 设置图例，标签，刻度\n",
    "ax.legend(\n",
    "    ['get_qfisher_norm()', '$4+2\\\\sin\\\\theta+2\\\\cos\\\\theta-2\\\\sin\\\\theta\\\\cos\\\\theta$'], \n",
    "    loc='best', prop= {'size': label_font_size}, frameon=False,\n",
    ")\n",
    "ax.set_xlabel('$\\\\theta$', fontsize=label_font_size)\n",
    "ax.set_ylabel('QFI norm along $v=(1,1,1,1)$', fontsize=label_font_size)\n",
    "ax.set_ylim([-1, 9])\n",
    "ax.tick_params(labelsize=label_font_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到程序的输出和解析结果是一致的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 计算有效量子维数\n",
    "\n",
    "利用量桨，我们可以通过调用 `get_eff_qdim()` 方法方便地计算有效量子维数（effective quantum dimension, EQD）。以下是上面提到的 hardware-efficient 拟设的 EQD 计算示例。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Ry(4.207)----*----Ry(2.825)--\n",
      "               |               \n",
      "--Ry(1.769)----x----Ry(4.774)--\n",
      "                               \n",
      "The number of parameters is 4.\n",
      "The EQD is 3. \n",
      "\n"
     ]
    }
   ],
   "source": [
    "cir = circuit_hardeff_2qubit()\n",
    "qf = QuantumFisher(cir)\n",
    "print(cir)\n",
    "print(f'The number of parameters is {len(cir.param.tolist())}.')\n",
    "print(f'The EQD is {qf.get_eff_qdim()}. \\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在这个例子中，EQD 比参数个数要少，这实际上可以通过控制电路上两个 $R_y$ 可以直接合并这一点上看出来。这可以通过替换其中一个 $R_y$ 门为 $R_x$ 门来修复，这会使得 EQD 增长 1。\n",
    "\n",
    "如果继续在电路上增加门，EQD 会无限增长吗？答案显然是不会，这是因为对于 $n$ 个量子比特，量子态的实数自由度为 $2\\cdot 2^n-2$，其中减 $2$ 是由于归一化和全局相位无关性这两条约束。这说明无论门的数量为多少，EQD 都不会超过 $2\\cdot 2^n-2$。我们可以通过下面的例子做一简单的验证。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Ry(1.794)----Rx(3.255)----*----Ry(2.579)----Rx(4.742)--\n",
      "                            |                            \n",
      "--Ry(1.964)----Rx(1.118)----x----Ry(1.707)----Rx(0.770)--\n",
      "                                                         \n",
      "The number of parameters is 8.\n",
      "The EQD is 6. \n",
      "\n"
     ]
    }
   ],
   "source": [
    "def circuit_hardeff_overparam():\n",
    "    cir = Circuit(2)\n",
    "    cir.ry()\n",
    "    cir.rx()\n",
    "    cir.cnot([0, 1])\n",
    "    cir.ry()\n",
    "    cir.rx()\n",
    "\n",
    "    return cir\n",
    "\n",
    "\n",
    "cir = circuit_hardeff_overparam()\n",
    "qf = QuantumFisher(cir)\n",
    "print(cir)\n",
    "print(f'The number of parameters is {len(cir.param.tolist())}.')\n",
    "print(f'The EQD is {qf.get_eff_qdim()}. \\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 计算经典费舍信息和有效维数\n",
    "\n",
    "这里我们举一个简单的例子来展示如何利用量桨对于一个量子神经网络计算式 (16) 中的有效维数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "调用飞桨定义量子神经网络和相应的损失函数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import paddle.nn as nn\n",
    "from paddle_quantum.gate import IQPEncoding, ComplexEntangledLayer, RX\n",
    "from paddle_quantum.hamiltonian import Hamiltonian\n",
    "from paddle_quantum.state import zero_state\n",
    "\n",
    "class QuantumNeuralNetwork(nn.Layer):\n",
    "    def __init__(self, num_qubits, depth, encoding):\n",
    "        super().__init__()\n",
    "        self.num_qubits, self.encoding = num_qubits, encoding\n",
    "        self.S = [[i, i + 1] for i in range(num_qubits - 1)]\n",
    "        self.init_state = zero_state(num_qubits)\n",
    "        \n",
    "        if encoding == 'IQP':\n",
    "            self.complex_layer = nn.LayerList([ComplexEntangledLayer(num_qubits=num_qubits, depth=depth)])\n",
    "        elif encoding == 're-uploading':\n",
    "            self.complex_layers = nn.LayerList([ComplexEntangledLayer(num_qubits=num_qubits) for _ in range(depth + 1)])\n",
    "        else:\n",
    "            raise RuntimeError('Non-existent encoding method')\n",
    "\n",
    "    def forward(self, x):\n",
    "        if not paddle.is_tensor(x):\n",
    "            x = paddle.to_tensor(x, dtype='float32')\n",
    "\n",
    "        state = self.init_state\n",
    "        if self.encoding == 'IQP':\n",
    "            state = IQPEncoding(x, qubits_idx=self.S)(state)\n",
    "            state = self.complex_layer[0](state)\n",
    "        else:\n",
    "            for i in range(depth):\n",
    "                state = self.complex_layers[i](state)\n",
    "                for j in range(num_qubits):\n",
    "                    state = RX(j, param=x[j].item())(state)\n",
    "            state = self.complex_layers[depth](state)\n",
    "\n",
    "        return state.expec_val(Hamiltonian([[1.0, 'z0']])) * 0.5 + 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后，定义 CFIM 计算器并计算不同大小的训练集对应的有效维数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "running in get_gradient: 100%|##################################| 1000/1000 [00:45<00:00, 22.07it/s]\n"
     ]
    }
   ],
   "source": [
    "from paddle_quantum import set_backend\n",
    "\n",
    "# 配置模型参数\n",
    "num_qubits = 4\n",
    "depth = 2\n",
    "num_inputs = 100\n",
    "num_thetas = 10\n",
    "set_backend('state_vector')\n",
    "# 定义 CFIM 计算器\n",
    "cfim = ClassicalFisher(model=QuantumNeuralNetwork,\n",
    "                       num_thetas=num_thetas,\n",
    "                       num_inputs=num_inputs,\n",
    "                       num_qubits=num_qubits,\n",
    "                       depth=depth,\n",
    "                       encoding='IQP')\n",
    "# 计算归一化的 CFIM\n",
    "fim, _ = cfim.get_normalized_cfisher()\n",
    "# 计算不同样本大小对应的有效维数\n",
    "n = [5000, 8000, 10000, 40000, 60000, 100000, 150000, 200000, 500000, 1000000]\n",
    "effdim = cfim.get_eff_dim(fim, n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "画出有效维数与参数个数之比随训练集大小的变化规律。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the number of parameters：24\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 648x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(9, 6))\n",
    "ax = fig.add_subplot(111)\n",
    "print('the number of parameters：%s' % cfim.num_params)\n",
    "ax.plot(n, np.array(effdim) / cfim.num_params)\n",
    "label_font_size = 14\n",
    "ax.set_xlabel('sample size', fontsize=label_font_size)\n",
    "ax.set_ylabel('effective dimension / number of parameters', fontsize=label_font_size)\n",
    "ax.tick_params(labelsize=label_font_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "\n",
    "本教程从几何的角度简要介绍了经典费舍信息和量子费舍信息的概念及二者之间的关系，并以有效维数为例阐述了它们在量子机器学习中的应用，最后展示了如何调用量桨来具体地计算它们。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_______\n",
    "\n",
    "## 参考文献\n",
    "\n",
    "[1] Meyer, Johannes Jakob. \"Fisher information in noisy intermediate-scale quantum applications.\" [arXiv preprint arXiv:2103.15191 (2021).](https://arxiv.org/abs/2103.15191)\n",
    "\n",
    "[2] Haug, Tobias, Kishor Bharti, and M. S. Kim. \"Capacity and quantum geometry of parametrized quantum circuits.\" [arXiv preprint arXiv:2102.01659 (2021).](https://arxiv.org/abs/2102.01659)\n",
    "\n",
    "[3] Stokes, James, et al. \"Quantum natural gradient.\" [Quantum 4 (2020): 269.](https://quantum-journal.org/papers/q-2020-05-25-269/)\n",
    "\n",
    "[4] Mari, Andrea, Thomas R. Bromley, and Nathan Killoran. \"Estimating the gradient and higher-order derivatives on quantum hardware.\" [Physical Review A 103.1 (2021): 012405.](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.103.012405)\n",
    "\n",
    "[5] Datta, Nilanjana, and Felix Leditzky. \"A limit of the quantum Rényi divergence.\" [Journal of Physics A: Mathematical and Theoretical 47.4 (2014): 045304.](https://iopscience.iop.org/article/10.1088/1751-8113/47/4/045304)\n",
    "\n",
    "[6] Abbas, Amira, et al. \"The power of quantum neural networks.\" [Nature Computational Science 1.6 (2021): 403-409.](https://www.nature.com/articles/s43588-021-00084-1)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "2ab84abaf8d5bbc8765aba8eb82d11e7069f2ff20e8f79b8a9cdeccefd2ac4da"
  },
  "kernelspec": {
   "display_name": "Python 3.8.13 ('pq_new')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
